###  Aplicação de QCA sobre os dados previamente gerados
###   Entrada: tabela-verdade (simultanea e lagged)

########################################################
## WD já setado via abertura do projeto
setwd("~/R/explorar set2025")
## zera todos os objetos
#rm(list = ls()) 

#######################################################
# instalação de pacotes QCA - feita em 05out2022
# do script do Patrick Mello
#install.packages("QCA")
#install.packages("SetMethods")
#install.packages("readxl")
library("QCA")
library("SetMethods")
# do script do Adrian na disciplina
library(dplyr) # data transformation
library(tibble) # column to rownames
library(devtools) # session info and parameters
library(formattable) # nicer truth tables
# para ler arquivos xls
library(readxl)
# para gravar arquivos xls (com limitações)
library(writexl)
# para gráficos
library(ggplot2)
library(readr)
library(dplyr)
# para processamento de datas
library(lubridate)


#  soluções de emergência
# se rodar em outro ambiente: usar comando setwd
#  se der pau na leitura direta do xls, converter arquivos de 
#  entrada excel em csv e usar no estilo:
#                  modelo = read.csv("Polity V.csv", header = TRUE, sep = ";")


#################################################################
########################### funções pré-programadas
#################################################################
#### nome.funcao <- function(parm.funcao)
####   {  #begin function
#### comandos da funcao  
#### return (resultado.funcao) 
####  fim da função
####   }  #endfunction


########## função compacta nomes de variaveis de entrada para um padrão de 4 caracteres

compacta.nomes.variaveis <- function (parm.matriz.entrada)
{ # begin function
for (i in (1:ncol(parm.matriz.entrada)))
  {
  if (colnames(parm.matriz.entrada) [i] == "POWERFUL_PRES")
      {colnames(parm.matriz.entrada) [i] <- "PWRP"}
  if (colnames(parm.matriz.entrada) [i] == "RECONC_PARTY_GOAL")
     {colnames(parm.matriz.entrada) [i] <- "RECP"}
  if (colnames(parm.matriz.entrada) [i] == "ABOVE_40_PCT")
      {colnames(parm.matriz.entrada) [i] <- "40PC"}
  if (colnames(parm.matriz.entrada) [i] == "POLARIZED")
      {colnames(parm.matriz.entrada) [i] <- "PLRZ"}     
  if (colnames(parm.matriz.entrada) [i] == "SINGLE_PARTY_CAB")
      {colnames(parm.matriz.entrada) [i] <- "SNGP"} 
  if (colnames(parm.matriz.entrada) [i] == "PARTISAN_CAB")
      {colnames(parm.matriz.entrada) [i] <- "PRTS"} 
  if (colnames(parm.matriz.entrada) [i] == "ACCOUNTABILITY")
     {colnames(parm.matriz.entrada) [i] <- "ACCT"} 
  if (colnames(parm.matriz.entrada) [i] == "LONG_MANDATE")
      {colnames(parm.matriz.entrada) [i] <- "LONG"} 
  } # end-for
return (parm.matriz.entrada)
} # end-function


########## função filtra mandados emergenciais
###                 (retira da base mandatos lameduck, de vice-presidentes e 
###                   de substitutos dos mandatários eleitos)

filtra.mandatos.emergenciais <- function (parm.matriz.entrada, parm.matriz.de.filtro,
                                          parm.retira.lameduck, parm.retira.vice, 
                                          parm.retira.bombeiro)
{ # begin function
  
  matriz.saida <- parm.matriz.entrada

  for (i in 1:nrow(parm.matriz.entrada))
  {

#     parm.long.como.filtro.exclusao transforma a variável LONG em
#     0 se for um dos casos de mandato escolhido para filtrar (lameduck,
#     vice-presidente ou bombeiro ou 1 se não for)       
    if (parm.long.como.filtro.exclusao)  
    {matriz.saida$LONG [i] <- 1}

    aux.retira.mandato <- FALSE
    for (j in 1:nrow(parm.matriz.de.filtro))
    {


    

    if (rownames (parm.matriz.entrada) [i] == parm.matriz.de.filtro$CASE_NAME [j])
    {
      if ( (parm.retira.lameduck & (parm.matriz.de.filtro$ELECTION_YEAR [j] != 0))  |
          (parm.retira.vice & (parm.matriz.de.filtro$VICE_PRESIDENT [j]  != 0)) |
           (parm.retira.bombeiro & (parm.matriz.de.filtro$EMERGENCY [j] != 0))
           )
      {aux.retira.mandato <- TRUE}
    }
    }  #  end-for
    
    if (aux.retira.mandato)
    {
      if (parm.long.como.filtro.exclusao)
      {matriz.saida$LONG [i] <- 0}
      else
      {matriz.saida <- matriz.saida [-i, ]}
      # end if-else
    }
    # end if
  } # end-for
 return (matriz.saida) 
} # end function
  

########## função gera gráficos inspeção da matriz de dados




gera.grafico.inspecao <- function (parm.tabela.verdade, parm.lagged)
{ # begin function
  if (parm.lagged == 0)
  {tipo.grafico <- "Contemporary outcome case matrix - "
  tipo.grafico.titulo <- ".contemporary"}
  else
  {tipo.grafico <- "Lagged outcome case matrix - "
  tipo.grafico.titulo <- ".lagged."}
  
  for (i in 1:ncol(parm.tabela.verdade))
  { # begin for
    
    if (parm.analisa.por.mandato)
    {aux.eixo.horizontal <- "Number of presidential mandate segments"}
    else
    { aux.eixo.horizontal <-"Number of governments (country-years)"}  
    
    
    #    gera histogramas
    variable.histogram <- ggplot(data=parm.tabela.verdade) + 
      geom_histogram(mapping = aes(x = parm.tabela.verdade [,i])) +
      labs(x=paste0 ("Fuzzy values of ", colnames(parm.tabela.verdade) [i]), 
           y = aux.eixo.horizontal, 
           title = paste0 (tipo.grafico, "Histograms")) +
      theme(axis.text=element_text(size=6)) +
      theme(axis.title=element_text(size=9)) + 
      theme(plot.title=element_text(size=5))
    
    
    # geom_vline(aes(xintercept = average.non.partisan.share), 
    #    non.partisan.stats, color = "red", linewidth = 1) +
    
    # Print plot to a jpeg file (vai descarregar na pasta principal do projeto)
    #  (poderia gerar em PDF mas o arquivo fica travado até fechar a sessão do RStudio)
    nome.arquivo.printado <- paste0 (colnames(parm.tabela.verdade) [i], tipo.grafico.titulo, ".histogram.jpg")
    
    if (parm.analisa.por.mandato)
    {nome.arquivo.printado <- paste0 ("Mandato.", nome.arquivo.printado)}
    
        
    ggsave(variable.histogram, 
           filename = nome.arquivo.printado,
           device = "jpeg", 
           height = 3, width = 4, units = "in")
    # dev.off() - tomar cuidado com esse comando, ele apagou outras vezes a tela de exibição dos plots
    
    
    #    gera scatterplots do outcome contra cada condicao causal
    
    
    #if (colnames(parm.tabela.verdade [i]) != "OUTCOME")
    #{
    
    valores.condicao <- parm.tabela.verdade [,i]
    valores.outcome <-  parm.tabela.verdade [,ncol(parm.tabela.verdade)]
    nome.condicao <- colnames(parm.tabela.verdade [i])
    nome.outcome <-  colnames (parm.tabela.verdade [ncol(parm.tabela.verdade)])
    variable.scatterplot <- ggplot(data=parm.tabela.verdade) + 
      geom_point(mapping = aes(x = valores.condicao, y = valores.outcome)) +
      labs (x=paste0 ("Fuzzy values of ", nome.condicao), 
            y = paste0 ("Fuzzy values of ", nome.outcome),
            title = paste0 (tipo.grafico, "Scatterplot conditions vs. outcome of ", nome.condicao)) +
      theme(axis.text=element_text(size=6)) +
      theme(axis.title=element_text(size=9)) +
      theme(plot.title=element_text(size=5))
    
    
    
    # geom_vline(aes(xintercept = average.non.partisan.share), 
    #    non.partisan.stats, color = "red", linewidth = 1) +
    
    # Print plot to a jpeg file (vai descarregar na pasta principal do projeto)
    #  (poderia gerar em PDF mas o arquivo fica travado até fechar a sessão do RStudio)

    nome.arquivo.printado <- paste0 (colnames(parm.tabela.verdade) [i], tipo.grafico.titulo, ".scatterplot.jpg")
    
    
    if (parm.analisa.por.mandato)
    {nome.arquivo.printado <- paste0 ("Mandato.", nome.arquivo.printado)}
    
    
    ggsave(variable.scatterplot, 
           filename = nome.arquivo.printado,
           device = "jpeg", 
           height = 3, width = 4, units = "in")
    # dev.off() - tomar cuidado com esse comando, ele apagou outras vezes a tela de exibição dos plots
    #}  # END if
    
  } # end for 
  
}  #  end function


########## função análise de necessidade - operação QCA
###########
analise.necessidade <- function(parm.matriz,parm.outcome,
                                parm.consistencia.necessidade)
{    #begin function
  
  
  saida.necessity.raw <- superSubset(parm.matriz, outcome = parm.outcome,
                                     incl.cut = parm.consistencia.necessidade)
  
  
  saida.necessity <- saida.necessity.raw$incl.cov
  
  combinations.found <-   as.data.frame (rownames (saida.necessity))
  
  saida.necessity <- cbind (combinations.found, saida.necessity)
  
  saida.necessity$inclN <- round (saida.necessity$inclN, digits = 4)
  saida.necessity$RoN <- round (saida.necessity$RoN, digits = 4)
  saida.necessity$covN <- round (saida.necessity$covN, digits = 4)
  colnames (saida.necessity) [1] <- "Combinations Found"
  
  return (saida.necessity) 
}  #endfunction

########## função redução das colunas matriz de entrada
###  retira condicoes não incluídas na rodada

reduz.matriz.entrada <- function(parm.matriz,
                                parm.inclui.non.party,
                                parm.inclui.polarization,
                                parm.inclui.single.party,
                                parm.inclui.long.mandate)
{    #begin function
  

parm.matriz.reduzida <- parm.matriz

if (parm.inclui.non.party != TRUE)
{parm.matriz.reduzida <-  subset(parm.matriz.reduzida, select = -PRTS) }
if (parm.inclui.polarization != TRUE)
{parm.matriz.reduzida <-  subset(parm.matriz.reduzida, select = -PLRZ) }
if ( (! parm.inclui.long.mandate ) | (parm.expurga.mandato.um.ano)) 
{parm.matriz.reduzida <-  subset(parm.matriz.reduzida, select = -LONG ) }
if (parm.inclui.single.party != TRUE) 
{parm.matriz.reduzida <-  subset(parm.matriz.reduzida, select = -SNGP ) }

return (parm.matriz.reduzida) 
} # end function
#######  



########## função gera tabela verdade - operação QCA

gera.tabela.verdade <- function(parm.matriz, parm.outcome, 
                                parm.consistencia, parm.frequencia,
                                parm.pri, parm.conditions,
                                parm.inclui.non.party,
                                parm.inclui.polarization,
                                parm.inclui.single.party,
                                parm.complete, parm.show.cases,
                                aplica.ESA, parm.negacao.ESA)
{
  # parâmetros default:
  # ao preencher o box “Complete”, acrescenta o parâmetro “complete = TRUE”
  # ao colocar algum cutoff numérico “n” para PRI,  acrescenta o parâmetro “pri.cut = n”
  

  
  saida.truth.table <- truthTable(parm.matriz, outcome = parm.outcome, 
                                  conditions = parm.conditions, 
#     conditions = "PWRP, RECP, 40PC, PRTS, ACCT, PLRZ", 
                                  incl.cut = parm.consistencia,
                                  pri.cut = parm.pri,
                                  n.cut = parm.frequencia,
                                  exclude = NULL,
                                  show.cases = parm.show.cases, complete = parm.complete,
                                  sort.by = "out, incl, n")
  
  
  
  if (aplica.ESA)
  {
    if (! parm.negacao.ESA)
        {ESA.exclui.linhas <-  findRows(obj = saida.truth.table,
               "~PWRP*~RECP*~40PC	+ ~ACCT + ~LONG")}
    else
        {ESA.exclui.linhas <- findRows(obj = saida.truth.table,
               "~PWRP*~RECP*~40PC	+ ACCT + LONG")}
     ## end-if-else
    
     saida.truth.table <- truthTable(parm.matriz, outcome = parm.outcome, 
                                    conditions = parm.conditions, 
                                    #     conditions = "PWRP, RECP, 40PC, PRTS, ACCT, PLRZ", 
                                    incl.cut = parm.consistencia,
                                    pri.cut = parm.pri,
                                    n.cut = parm.frequencia,
                                    exclude = ESA.exclui.linhas,
                                    show.cases = parm.show.cases, complete = parm.complete,
                                    sort.by = "out, incl, n")
     } #  end-if  (aplica ESA)
  
  
  saida.truth.table$tt$incl <- as.numeric(saida.truth.table$tt$incl)
  saida.truth.table$tt$PRI <- as.numeric(saida.truth.table$tt$PRI)
  
  
  
  for (k in (1:nrow(saida.truth.table$tt))) 
  {
    if (!is.na (saida.truth.table$tt$incl [k]))
    {
      saida.truth.table$tt$incl[k] <- round (saida.truth.table$tt$incl [k], digits = 4)
      saida.truth.table$tt$PRI [k] <- round (saida.truth.table$tt$PRI [k], digits = 4)
      # idealmente, aqui caberia calcular de forma centralizada a razão PRI/incl
      #  mas isso levaria a uma mudança na estrutura de dados que sai da função truthtable,
      # e que é usada depois na minimização. Por isso, essa nova variável está sendo calculada
      # quando da utilização da saída desta função depois de cada chamada
      }  
  }
  
    return (saida.truth.table) 
}  #endfunction

### funcao grava solucões minimizadas 
#  provisoriamente desativada por inconsistências na identificação
#   da estrutura correta da solução intermediária; substituída
#   pela gravação em txt do console

grava.minimized <- function(parm.solucoes, parm.solucoes.combinadas,
                           parm.tipo, parm.label.simplifying.assumptions,
                           parm.simplifying.assumptions) 
{
prime.implicants <- parm.solucoes

Combined.solutions <- rownames(prime.implicants)
prime.implicants <- cbind(Combined.solutions, data.frame(prime.implicants, row.names=NULL))

aux.solucao.completa <- cbind("Combined solutions", parm.solucoes.combinadas, " ", " ")
colnames (aux.solucao.completa) <- colnames (prime.implicants)
prime.implicants <- rbind (prime.implicants, aux.solucao.completa)
prime.implicants$PRI.as.pct.Consist <- round ((prime.implicants$PRI / prime.implicants$incl), digits = 4)  
prime.implicants <- prime.implicants %>% relocate(PRI.as.pct.Consist, .after = PRI) 

aux.label <- cbind(parm.tipo, " ", " ", " ", " ", " ", " ")
colnames(aux.label) <- colnames (prime.implicants)
prime.implicants <- rbind (aux.label, prime.implicants)

aux.simplifying <- prime.implicants
aux.simplifying <- aux.simplifying [1,]
for (i in (1 : ncol(aux.simplifying)))
{ aux.simplifying [1,i] <-" " }

if ( !is.null(parm.simplifying.assumptions) )
{ 
aux.simplifying [1,1] <- parm.label.simplifying.assumptions
prime.implicants <- rbind (prime.implicants, aux.simplifying)
for (i in 1 : ncol (parm.simplifying.assumptions))
{ aux.simplifying [1,i] <- colnames(parm.simplifying.assumptions) [i] } 
prime.implicants <- rbind (prime.implicants, aux.simplifying)
for (k in 1: nrow (parm.simplifying.assumptions))
{
for (i in 1 : ncol (parm.simplifying.assumptions))
{ aux.simplifying [k,i] <- parm.simplifying.assumptions [k,i]}  
}
}
prime.implicants <- rbind (prime.implicants, aux.simplifying)


return (prime.implicants) 
}  #endfunction

#### funcao round.parm.minimizacao
####     arredonda para quatro casas decimais os valores numéricos de
####     parametros de minimização, já usando os arquivos que foram 
####    formatados como saida para gravacao de cada solucao
####    para permitir a transcrição para o texto em word
 
round.parm.minimizacao <- function(arquivo.base.gravacao)
{  #begin function

#arquivo.base.gravacao <- as.data.frame(arquivo.base.gravacao)

for ( k in 1:nrow (arquivo.base.gravacao) )
{

if  (  
        ! is.na (as.numeric (arquivo.base.gravacao$inclS [k]))    &
        arquivo.base.gravacao$inclS [k] != "0" &
        arquivo.base.gravacao$inclS [k]  != "1"         
     )
    { arquivo.base.gravacao$inclS [k] <- round (as.numeric(arquivo.base.gravacao$inclS [k]), digits = 4) }
 
 if  (  
        ! is.na (as.numeric (arquivo.base.gravacao$PRI [k]))    &
        arquivo.base.gravacao$PRI [k] != "0" &
        arquivo.base.gravacao$PRI [k]  != "1"         
     )
    { arquivo.base.gravacao$PRI [k] <- round (as.numeric(arquivo.base.gravacao$PRI [k]), digits = 4) }
  
  if  (  
        ! is.na (as.numeric (arquivo.base.gravacao$PRI.as.pct.Consist [k]))    &
        arquivo.base.gravacao$PRI.as.pct.Consist [k] != "0" &
        arquivo.base.gravacao$PRI.as.pct.Consist [k]  != "1"         
     )
    { arquivo.base.gravacao$PRI.as.pct.Consist [k] <- round (as.numeric(arquivo.base.gravacao$PRI.as.pct.Consist [k]), digits = 4) }
  
    if  (  
        ! is.na (as.numeric (arquivo.base.gravacao$covS [k]))    &
        arquivo.base.gravacao$covS [k] != "0" &
        arquivo.base.gravacao$covS [k]  != "1"         
     )
    { arquivo.base.gravacao$covS [k] <- round (as.numeric(arquivo.base.gravacao$covS [k]), digits = 4) }

  
    if  (  
        ! is.na (as.numeric (arquivo.base.gravacao$covU [k]))    &
        arquivo.base.gravacao$covU [k] != "0" &
        arquivo.base.gravacao$covU [k]  != "1"         
     )
    { arquivo.base.gravacao$covU [k] <- round (as.numeric(arquivo.base.gravacao$covU [k]), digits = 4) }

}
return (arquivo.base.gravacao)
}  #endfunction

#### funcao imprime.console.para.conferencia
# imprime em arquivo a tabela verdade gerada no console
# (para consistir com a saída construída em excel)

imprime.console.para.conferencia <- function(console.para.imprimir,
                                             parm.tipo.saida, # se tt ou minimização, junto com 
                                                              # as condicoes adicionadas ao modelo básico
                                             parm.arquivo.outcome, # se é outcome ou negação 
                                             parm.arquivo.tempo,# se é sameyear ou lagged
                                             parm.append,  # se vai acrescentar ou sobrepor ao arquivo de texto 
                                             parm.titulo, #  título de cada gravacao no caso de usar acréscimo (append)
                                             parm.confere.consistencia.min)  #  indica se usou threshold de consistencia no
                                                                        # para solucoes de minimizacao
{  #begin function

 #  cria parte do nome indicando conferencia de consistencia
 # das soluções
 if (parm.confere.consistencia.min == 0)
 { nome.inicial.arquivo <- "console"}
  else
  {nome.inicial.arquivo <- paste("console.c", as.character (parm.confere.consistencia.min), sep="")}
  # especifica nome do arquivo de impressao
if (aplica.ESA)  
{nome.inicial.arquivo <- paste(nome.inicial.arquivo, ".ESA",sep="")}
  
nome.arquivo.impressao <- paste (nome.inicial.arquivo, parm.tipo.saida, 
                                   parm.arquivo.tempo, parm.arquivo.outcome,
                                   "txt", sep=".")  
#gera arquivo auxiliar (quando tem que gerar arquivo novo)

if (parm.append == FALSE)
 {auxiliar.impressao <- "IMPRESSAO TABELA VERDADE"
  auxiliar.impressao <- as.data.frame (auxiliar.impressao)
  write.table (auxiliar.impressao, file = nome.arquivo.impressao)}
# redireciona console para arquivo
sink (nome.arquivo.impressao, append = parm.append)
if (! is.na(parm.titulo))
{print(parm.titulo)}
# end-if
options (width = 400)
print (nome.arquivo.impressao)
print(console.para.imprimir)
options (width = 80)
# fecha o direcionamento do console para arquivo
sink ()
##  fim impressão direta da tabela verdade

##  gera imagem do texto para acrescentar à planilha excel

imagem.console <- read.table (nome.arquivo.impressao, sep='\t')


return (imagem.console)

} # end function


###  procedure section (lembrança do cobol)

#################################################################
###########################SETA PARAMETROS GERAIS
#################################################################



parm.inclui.non.party <-FALSE # incluindo ou não non-partisan,
parm.inclui.polarization <- FALSE  # incluindo ou não polarization
#
parm.inclui.single.party <- FALSE # incluindo ou não single party
####      single party não existe na entrada por mandatos ( a combinação
####      inclui.single.party = TRUE e analisa.por.mandato = TRUE vai dar erro
####      na função reduz.matriz.entrada)
#
parm.inclui.long.mandate <- TRUE # incluindo ou não long mandate
####      long.mandate não existe na entrada por ano-pais ( a combinação
####      inclui.long.mandate = TRUE e analisa.por.mandato = FALSE vai dar erro
####      na função reduz.matriz.entrada)
parm.long.como.filtro.exclusao <- TRUE

parm.expurga.mandato.um.ano <- FALSE  # retira da entrada os mandatos de apenas
###  um ano. Evidentemente, é incompatível com parm.inclui.long.mandate = true 
###  e com parm.analisa.por.mandato = false


parm.retira.lameduck <- TRUE # retira da base os gabinetes minoritários de um ano 
                              # coincidentes com anos de eleição presidencial

parm.retira.vice <- TRUE # retira da base os gabinetes minoritários de um ano 
                           # presididos por vice-presidentes que assumiram em 
                           # lugar dos titulares por qualquer motivo

parm.retira.bombeiro <- TRUE # retira da base os gabinetes minoritários de um ano 
                              # presididos por presidentes nomeados em procedimentos
                              # excepcionais para substituir presidentes e vices eleitos


  
parm.complete <- TRUE
parm.show.cases <- FALSE

performance.duas.variaveis <- TRUE  # indica se usa entrada de performance com
# duas variáveis (se false, usa com 4)

parm.analisa.por.mandato <- TRUE  #  indica se a matriz de casos está organizada
#    por mandatos (ou segmentos contínuos de mandato), em lugar de por ano-país                                    

aplica.ESA <- FALSE  # aplica ou não ESA - Enhanced Standard Analysis



#   fixa parametros de necessidade
#   fixa limiar de consistencia para necessidade (padrão da literatura: 0,9)

consistency.threshold.for.necessity <- 0.9



# fixa parâmetros de consistência e frequencia para suficiencia

parm.consistencia <- 0.8  # limiar de consistencia para as linhas da tabela-verdade

confere.consistencia.minimizacao <- FALSE # fixando ou não limiar de consistencia
# também para as soluções combinadas da minimizacao
### atenção: usar esse parâmetro TRUE termina inevitavelmente com a sessão do R abortada



if (confere.consistencia.minimizacao)
{parm.consistencia.minimizacao <- 0.8} else 
  # else
{parm.consistencia.minimizacao <- 0}
#endif
parm.frequencia <- 3
parm.pri <- 0.6



#################################################################
########################### carga de dados - tabela verdade
#################################################################
#tabela.verdade = read_xls("planilha.saida.governos.minoritarios.xls", sheet = "Tabela_verdade")
#tabela.verdade.lagged = read_xls("planilha.saida.governos.minoritarios.xls", sheet = "Tabela_verdade_lagged")


##
# opção pela solução "comum" em lugar da ampliada (com variável non-partisan cabinet)
#  desativada - a seleção de variáveis vai ser feita posteriormenet
##
#
solucao.ampliada <- 1  # 1 = usa solucao ampliada (parm.inclui.non.party está no default TRUE); 
#                         outro valor = usa solucao comum (setar parm.inclui.non.party = FALSE);
# 
#if (solucao.ampliada == 1 )
#  { 
#    matriz.de.casos.lagged.carga <- read.csv("matriz.de.casos.lagged.ampliada.csv", row.names = 1, fileEncoding = "UTF-8-BOM")
#    matriz.de.casos.mesmo.ano.carga <- read.csv("matriz.de.casos.mesmo.ano.ampliada.csv", row.names = 1, fileEncoding = "UTF-8-BOM") 
#  } else
#  { matriz.de.casos.lagged.carga <- read.csv("matriz.de.casos.lagged.csv", row.names = 1, fileEncoding = "UTF-8-BOM")
#  matriz.de.casos.mesmo.ano.carga <- read.csv("matriz.de.casos.mesmo.ano.csv", row.names = 1, fileEncoding = "UTF-8-BOM") 
#  }
##
# opção pela construção da policy performance com duas variáveis (GDP, income distribution)
#   - se falso, utilizará quatro, acrescentando inflation e unemployment
# (a matriz de casos de ambos já saiu pronta do script anterior)
##
#

#   carrega a matriz de casos por mandato
if (parm.analisa.por.mandato)
{
  matriz.de.casos.lagged.carga <- read.csv("matriz.de.casos.por.mandato.lagged.csv", row.names = 1, fileEncoding = "UTF-8-BOM")
  matriz.de.casos.mesmo.ano.carga <- read.csv("matriz.de.casos.por.mandato.mesmo.ano.csv", row.names = 1, fileEncoding = "UTF-8-BOM") 
  
  if (parm.expurga.mandato.um.ano)  #  roda sem os mandatos de um ano
  {
    matriz.de.casos.lagged.carga <- subset (matriz.de.casos.lagged.carga, LONG == 1)
    matriz.de.casos.mesmo.ano.carga <- subset (matriz.de.casos.mesmo.ano.carga,LONG == 1)
  }    
  
} else 
# else # carrega a matriz de casos por ano.pais
  {
  if (performance.duas.variaveis )
    { 
      matriz.de.casos.lagged.carga <- read.csv("matriz.de.casos.lagged.ampliada.csv", row.names = 1, fileEncoding = "UTF-8-BOM")
      matriz.de.casos.mesmo.ano.carga <- read.csv("matriz.de.casos.mesmo.ano.ampliada.csv", row.names = 1, fileEncoding = "UTF-8-BOM") 
    } else
    { matriz.de.casos.lagged.carga <- read.csv("matriz.de.casos.lagged.ampliada.perf4v.csv", row.names = 1, fileEncoding = "UTF-8-BOM")
    matriz.de.casos.mesmo.ano.carga <- read.csv("matriz.de.casos.mesmo.ano.ampliada.perf4v.csv", row.names = 1, fileEncoding = "UTF-8-BOM") 
    }
  #  end-if-else
} # end-else
    
# reordena colunas para ordenar segundo a hipótese teórica
# (condicoes de decisiveness / ACCT / polarization)
if (! parm.analisa.por.mandato) # a matriz por mandato já vem na ordem correta de colunas
{    
  matriz.de.casos.mesmo.ano.carga <- matriz.de.casos.mesmo.ano.carga [, c(1, 2, 3, 5, 6, 7, 4, 8)]
  matriz.de.casos.lagged.carga <- matriz.de.casos.lagged.carga [, c(1, 2, 3, 5, 6, 7, 4, 8)]
}

## compacta nomes de condições para um padrão de quatro caracteres

matriz.de.casos.mesmo.ano.carga <- compacta.nomes.variaveis(matriz.de.casos.mesmo.ano.carga)
matriz.de.casos.lagged.carga <- compacta.nomes.variaveis(matriz.de.casos.lagged.carga)


## FILTRA DA BASE OS MANDATOS CONSIDERADOS EMERGENCIAIS OU INSUFICIENTES (lameducks,
##  vice-presidentes, bombeiros que assumiram em condições emergenciais)

matriz.de.filtro <- read.csv("Cases.by.mandate - one year and attributes.csv", sep=";", fileEncoding = "UTF-8-BOM")

matriz.de.casos.mesmo.ano.carga <- filtra.mandatos.emergenciais(matriz.de.casos.mesmo.ano.carga,
                                                                matriz.de.filtro,
                                                                parm.retira.lameduck, parm.retira.vice, parm.retira.bombeiro)
matriz.de.casos.lagged.carga <- filtra.mandatos.emergenciais(matriz.de.casos.lagged.carga,
                                                             matriz.de.filtro,
                                                             parm.retira.lameduck, parm.retira.vice, parm.retira.bombeiro)



#################################################################
########################### gera gráficos de inspeção das variaveis
#################################################################

# Hence, as a precaution, it is always useful to create histograms of individual 
# conditions and to plot these against the outcome before the actual analysis,
#  to examine whether any of these may later cause analytical problems.Apart
#  from theoretical considerations, this is another reason why one should strive 
# to have a reasonably even distribution of membership values for each condition.
# Mello, 2021, p. 113)

parm.lagged <- 0
parm.tabela.verdade <- matriz.de.casos.mesmo.ano.carga 
gera.grafico.inspecao (parm.tabela.verdade, parm.lagged)

parm.lagged <- 1
parm.tabela.verdade <- matriz.de.casos.lagged.carga 
gera.grafico.inspecao (parm.tabela.verdade, parm.lagged)



#################################################################
########################### analise de necessidade
#################################################################

# identifica superset (condicoes necessarias) 
# (função superSubset tem relation = "necessity" como default)

necessity.parameters <- as.data.frame(c("Necessity Consistency Threshold", consistency.threshold.for.necessity,
                                        "Analisa por mandato", parm.analisa.por.mandato,
                                        "Abre por mandatos de um ano e de mais de um", parm.inclui.long.mandate,
                                        "Inclui só mandatos de mais de um ano", parm.expurga.mandato.um.ano,
                                        "Exclui lame ducks (ano eleitoral)", parm.retira.lameduck,
                                        "Exclui vice-presidentes", parm.retira.vice,
                                        "Exclui mandatos-tampão", parm.retira.bombeiro))
                                        


# 1 - análise de necessidade para o outcome, mesmo ano

parm.matriz <- matriz.de.casos.mesmo.ano.carga
# carrega as colunas que não existem em cada caso, para chamar a função
#  de redução da matriz
if (parm.analisa.por.mandato)
{parm.matriz$SNGP <- NA}   else
#else
{parm.matriz$LONG <- NA}

 parm.matriz <- reduz.matriz.entrada (parm.matriz,
                                     parm.inclui.non.party,
                                     parm.inclui.polarization,
                                     parm.inclui.single.party,
                                     parm.inclui.long.mandate)

parm.outcome <- "OUTCOME"
parm.consistencia.necessidade <- consistency.threshold.for.necessity


saida.necessity <- analise.necessidade (parm.matriz,parm.outcome,
                                        parm.consistencia.necessidade)

necessity.outcome <- saida.necessity

# 2 - análise de necessidade para a negação do outcome, mesmo ano

parm.matriz <- matriz.de.casos.mesmo.ano.carga
if (parm.analisa.por.mandato == TRUE)
{parm.matriz$SNGP <- NA}   else
#else
{parm.matriz$LONG <- NA}


parm.matriz <- reduz.matriz.entrada (parm.matriz,
                                     parm.inclui.non.party,
                                     parm.inclui.polarization,
                                     parm.inclui.single.party,
                                     parm.inclui.long.mandate)

parm.outcome <- "~OUTCOME"
parm.consistencia.necessidade <- consistency.threshold.for.necessity

saida.necessity <- analise.necessidade (parm.matriz,parm.outcome,
                                        parm.consistencia.necessidade)

necessity.outcome.negation <- saida.necessity

# 3 - análise de necessidade para o outcome, lagged

parm.matriz <- matriz.de.casos.lagged.carga
if (parm.analisa.por.mandato == TRUE)
{parm.matriz$SNGP <- NA}   else
  #else
  {parm.matriz$LONG <- NA}


parm.matriz <- reduz.matriz.entrada (parm.matriz,
                                     parm.inclui.non.party,
                                     parm.inclui.polarization,
                                     parm.inclui.single.party,
                                     parm.inclui.long.mandate)

parm.outcome <- "OUTCOME_LAGGED"
parm.consistencia.necessidade <- consistency.threshold.for.necessity

saida.necessity <- analise.necessidade (parm.matriz,parm.outcome,
                                        parm.consistencia.necessidade)

necessity.outcome.lagged <- saida.necessity

# 4 - análise de necessidade para a negação do outcome, lagged


parm.matriz <- matriz.de.casos.lagged.carga
if (parm.analisa.por.mandato == TRUE)
{parm.matriz$SNGP <- NA}   else
  #else
  {parm.matriz$LONG <- NA}

parm.matriz <- reduz.matriz.entrada (parm.matriz,
                                     parm.inclui.non.party,
                                     parm.inclui.polarization,
                                     parm.inclui.single.party,
                                     parm.inclui.long.mandate)

parm.outcome <- "~OUTCOME_LAGGED"
parm.consistencia.necessidade <- consistency.threshold.for.necessity

saida.necessity <- analise.necessidade (parm.matriz,parm.outcome,
                                        parm.consistencia.necessidade)

necessity.outcome.negation.lagged <- saida.necessity


#################################################################
########################### analise de suficiencia
#################################################################

# ao preencher o box “Complete”, acrescenta o parâmetro “complete = TRUE”
# ao colocar algum cutoff numérico “n” para PRI,  acrescenta o parâmetro “pri.cut = n”
# utilizado o parâmetro default 1 para cutoff de frequency (“n.cut = 1” já é default; se não inserido, acrescenta “n.cut =”)
# sort by default: outcome, inclusion, frequency

# fixa parâmetros default:



####  gera parâmetro para identificar nomes de arquivos gravados

if (parm.inclui.non.party == TRUE)
{
  if (parm.inclui.polarization == TRUE)
  {
    if (parm.inclui.single.party == TRUE) 
    { parm.addition.filename <- "partis.polariz.singlep"}
    else
    {parm.addition.filename <- "partis.polariz"}
  }
  else
  {
    if (parm.inclui.single.party == TRUE) 
    { parm.addition.filename <- "partis.singlep"}
    else
    { parm.addition.filename <- "partis"}
  }
} else  
{
  if (parm.inclui.polarization == TRUE)
  {
    if (parm.inclui.single.party == TRUE) 
    { parm.addition.filename <- "polariz.singlep"}
    else
    { parm.addition.filename <- "polariz"}
  }
  else
  {
    if (parm.inclui.single.party == TRUE) 
    {parm.addition.filename <- "singlep" }
    else
    { parm.addition.filename <- ""}
  }
}
if (parm.analisa.por.mandato) # identifica o filename da análise por mandato
{
  parm.addition.filename <- paste ("mandato.", parm.addition.filename, sep = "")
  if (parm.inclui.long.mandate)
  {parm.addition.filename <- paste ("long.", parm.addition.filename, sep = "")}
  if (parm.expurga.mandato.um.ano)
  {parm.addition.filename <- paste ("expurg.", parm.addition.filename, sep = "")} 
  if (parm.retira.lameduck)
  {parm.addition.filename <- paste ("-lame.", parm.addition.filename, sep = "")} 
  if (parm.retira.vice)
  {parm.addition.filename <- paste ("-vice.", parm.addition.filename, sep = "")} 
  if (parm.retira.bombeiro)
  {parm.addition.filename <- paste ("-bomb.", parm.addition.filename, sep = "")} 
}

if (parm.show.cases)
{parm.addition.filename <- paste ("showcases.", parm.addition.filename, sep = "")} 
###
if (confere.consistencia.minimizacao)
 {inicial.nome.arquivo <- paste("QCA.results.c", as.character (parm.consistencia.minimizacao), sep="")}  else
#  else
 {inicial.nome.arquivo <- "QCA.results."}
if (aplica.ESA)
{ inicial.nome.arquivo <- paste (inicial.nome.arquivo, "ESA.", sep="") }


nome.arquivo.necessity <- paste (inicial.nome.arquivo, "necessity.", parm.addition.filename, ".xlsx", sep="" )
nome.arquivo.truthtable <-  paste (inicial.nome.arquivo, "truthtable.", parm.addition.filename, ".xlsx", sep="" )
nome.arquivo.sufficiency <-  paste (inicial.nome.arquivo, "sufficiency.", parm.addition.filename, ".xlsx", sep="" )

#############


sufficiency.parameters <- as.data.frame(c("Sufficiency Consistency Threshold", 
                                          parm.consistencia, 
                                          "Frequency Threshold", parm.frequencia,
                                          "PRI Threshold", parm.pri,
                                          "Minimization sufficiency Consistency Threshold", parm.consistencia.minimizacao,
                                          "Display tt no console", parm.complete,
                                          "Analisa por mandato", parm.analisa.por.mandato,
                                          "Abre por mandatos de um ano e de mais de um", parm.inclui.long.mandate,
                                          "Inclui só mandatos de mais de um ano", parm.expurga.mandato.um.ano,
                                          "Exclui lame ducks (ano eleitoral)", parm.retira.lameduck,
                                          "Exclui vice-presidentes", parm.retira.vice,
                                          "Exclui mandatos-tampão", parm.retira.bombeiro))

##  providencia preliminar: 
## monta as expectativas direcionais usando simplesmente valores isolados para cada condição
##
#    este primeiro if aninhado considera as expectativas de negation como
#    opostas às de outcome 


#if (parm.inclui.non.party == TRUE)
#{
#  if (parm.inclui.polarization == TRUE)
#  {
#    if (parm.inclui.single.party == TRUE) 
#    { directional.expectations.outcome <- "1, 1, 1, 1, 1, 1, 0"
#      directional.expectations.negation <- "0, 0, 0, 0, 0, 0, 1"
#    }

#    else
#    { directional.expectations.outcome <- "1, 1, 1, 1, 1, 0"
#    directional.expectations.negation <- "0, 0, 0, 0, 0, 1"
#    }
#  }
#  else
#  {
#    if (parm.inclui.single.party == TRUE) 
#    { directional.expectations.outcome <- "1, 1, 1, 1, 1, 1"
#    directional.expectations.negation <- "0, 0, 0, 0, 0, 0"
#    }
#    else
#    { directional.expectations.outcome <- "1, 1, 1, 1, 1"
#    directional.expectations.negation <- "0, 0, 0, 0, 0"
#    }
#  }
#}  else  
#{
#  if (parm.inclui.polarization == TRUE)
#  {
#    if (parm.inclui.single.party == TRUE) 
#    { directional.expectations.outcome <- "1, 1, 1, 1, 1, 0"
#    directional.expectations.negation <- "0, 0, 0, 0, 0, 1"
#    }
#    else
#    { directional.expectations.outcome <- "1, 1, 1, 1, 0"
#    directional.expectations.negation <- "0, 0, 0, 0, 1"
#    }
#  }
#  else
#  {
#    if (parm.inclui.single.party == TRUE) 
#    { directional.expectations.outcome <- "1, 1, 1, 1, 1"
#    directional.expectations.negation <- "0, 0, 0, 0, 0"
#    }
#    else
#    { directional.expectations.outcome <- "1, 1, 1, 1"
#    directional.expectations.negation <- "0, 0, 0, 0"
#    }
#  }
#}

## este próximo comando equipara o vetor de expectativas da negacao
## ao vetor do outcome (pois o pacote QCA trata automaticamente essa 
##  inversão lógica ao rodar a solucao intermediária)
##
#directional.expectations.negation <- directional.expectations.outcome


##
## monta as expectativas direcionais usando expressões condicionais
##
#    este segundo if aninhado, alternativa ao anterior, constroi
#  expressoes condicionais específicas para outcome e negated


decisiv.factor.1 <- "PWRP"
decisiv.factor.2 <- "RECP"
decisiv.factor.3 <- "40PC"
decisiv.factor.4 <- "PRTS"
decisiv.factor.5 <- "SNGP"
acct.factor <- "ACCT"
long.factor <- "LONG"

#  environ.factor1 <- "PLRZ"  # em princípio, PLRZ descartado na hipótese
#  por razoes teóricas
#  environ.factor2 <- "LONG"  # em princípio, LONG descartado na hipótese
#  por razoes teóricas
#   (ou seja, os fatores não diretamente associados pela teoria ao resultado governativó
#     não estão sendo incluídos nas expectativas direcionais para formar contrafactuais)



if (parm.inclui.non.party == TRUE)
{
  if (parm.inclui.single.party == TRUE) 
  { decisiv.conditions <- paste (decisiv.factor.1,"+",decisiv.factor.2,"+",
                                 decisiv.factor.3,"+",decisiv.factor.4,
                                 "+", decisiv.factor.5, sep="")
  }
  else
  { decisiv.conditions <- paste (decisiv.factor.1,"+",decisiv.factor.2,"+",
                                 decisiv.factor.3,"+",decisiv.factor.4, sep="")
  }   
} else
# else
  {   
  if (parm.inclui.single.party == TRUE) 
  {  decisiv.conditions <- paste (decisiv.factor.1,"+",decisiv.factor.2,"+",
                                  decisiv.factor.3,"+",decisiv.factor.5, sep="")
  }
  else
  { decisiv.conditions <- paste (decisiv.factor.1,"+",decisiv.factor.2,"+",
                                 decisiv.factor.3, sep="")
  }
}
# end-if-else
 
directional.expectations.outcome <- 
  c (paste("(",decisiv.conditions,")", "*", acct.factor, "*", long.factor, sep=""))
directional.expectations.negation <- 
  c (paste("(",decisiv.conditions,")", "*", "~", acct.factor, "*", "~", long.factor,sep=""))
######  se fosse incluir polarização nas expectativas direcionais
#   directional.expectations.outcome <- 
#    c (decisiv.conditions, acct.factor, paste("~", environ.factor, sep=""))
#  directional.expectations.negation <- 
#    c (paste("(",decisiv.conditions,")", "*", paste ("~", acct.factor, sep=""),sep=""),
#       environ.factor)
##################################################

if (parm.analisa.por.mandato) # a matriz de casos do mandato traz condições diferentes
{   #  especifica condições para a analise por mandato
  if (parm.inclui.non.party == TRUE)
  {
    if (parm.inclui.polarization == TRUE)
    {
      if (parm.inclui.long.mandate == TRUE)
      {parm.conditions <- "PWRP, RECP, 40PC, PRTS, ACCT, PLRZ, LONG"}
      else
      {parm.conditions <- "PWRP, RECP, 40PC, PRTS, ACCT, PLRZ"}
    }
    else
    {
      if (parm.inclui.long.mandate == TRUE)
      {parm.conditions <- "PWRP, RECP, 40PC, PRTS, ACCT, LONG"}  
      else
      {parm.conditions <- "PWRP, RECP, 40PC, PRTS, ACCT"}  
    }
  }
  else
  {
    if (parm.inclui.polarization == TRUE)
    {
      if (parm.inclui.long.mandate == TRUE)
      {parm.conditions <- "PWRP, RECP, 40PC, ACCT, PLRZ, LONG"}
    else
      {parm.conditions <- "PWRP, RECP, 40PC, ACCT, PLRZ"}
     } 
    else
    {
      if (parm.inclui.long.mandate == TRUE)
      {parm.conditions <- "PWRP, RECP, 40PC, ACCT, LONG"}
      else
      {parm.conditions <- "PWRP, RECP, 40PC, ACCT"}
    }
  }
} else # fim da especificação de condições para a analise por mandato
# else  
{  #  especifica condições para a analise por ano-pais
if (parm.inclui.non.party == TRUE)
{
  if (parm.inclui.polarization == TRUE)
  {
    if (parm.inclui.single.party == TRUE) 
    { parm.conditions <- "PWRP, RECP, 40PC, SNGP, PRTS, ACCT, PLRZ"}
    
    else
    { parm.conditions <- "PWRP, RECP, 40PC, PRTS, ACCT, PLRZ"}
  }
  else
  {
    if (parm.inclui.single.party == TRUE) 
    { parm.conditions <- "PWRP, RECP, 40PC, SNGP, PRTS, ACCT"}
    else
    { parm.conditions <- "PWRP, RECP, 40PC, PRTS, ACCT"}
  }
}        else  
  #else
{
  if (parm.inclui.polarization == TRUE)
  {
    if (parm.inclui.single.party == TRUE) 
    { parm.conditions <- "PWRP, RECP, 40PC, SNGP, ACCT, PLRZ"}
    else
    { parm.conditions <- "PWRP, RECP, 40PC, ACCT, PLRZ"}
  }
  else
  {
    if (parm.inclui.single.party == TRUE) 
    { parm.conditions <- "PWRP, RECP, 40PC, SNGP, ACCT"}
    else
    { parm.conditions <- "PWRP, RECP, 40PC, ACCT"}
  }
}
} # termina especificação de condições para a análise ano-pais





## TRABALHA COM A MATRIZ DE CASOS DO MESMO ANO

parm.matriz <- matriz.de.casos.mesmo.ano.carga


#  outcome

parm.outcome <- "OUTCOME"
parm.negacao.ESA <- FALSE
truthtable.sameyear.outcome <- gera.tabela.verdade (parm.matriz, parm.outcome, 
                                                    parm.consistencia, parm.frequencia,
                                                    parm.pri,parm.conditions,
                                                    parm.inclui.non.party,
                                                    parm.inclui.polarization,
                                                    parm.inclui.single.party,
                                                    parm.complete, parm.show.cases,
                                                    aplica.ESA, parm.negacao.ESA)

### imprime em arquivo a tabela verdade gerada no console
impressao.console <- imprime.console.para.conferencia (truthtable.sameyear.outcome$tt,
                               parm.tipo.saida = paste("tt", parm.addition.filename, sep="."), 
                               parm.arquivo.outcome = "outcome",
                               parm.arquivo.tempo = "sameyear",
                               parm.append = FALSE,
                               parm.titulo = NA,
                               parm.confere.consistencia.min = parm.consistencia.minimizacao)


sufficiency.outcome <- truthtable.sameyear.outcome$tt 
sufficiency.outcome$PRI.as.pct.Consist <- sufficiency.outcome$incl

for (k in 1:nrow(sufficiency.outcome))
{
  if ( is.numeric (sufficiency.outcome$incl [k]) )
  {
  sufficiency.outcome$PRI.as.pct.Consist [k] <- round ((sufficiency.outcome$PRI [k]/sufficiency.outcome$incl [k]), digits = 4)  
  }
}   # endfor
sufficiency.outcome <- sufficiency.outcome %>% relocate(PRI.as.pct.Consist, .after = PRI) 


#imprime a tabela verdade completa (1 planilha com todas as condições lógicas,
#  outra planilha com os casos)
TT.sameyear.outcome.save <-  sufficiency.outcome
TT.sameyear.outcome.save$NUMCASO <- rownames(sufficiency.outcome)
TT.sameyear.outcome.save <- TT.sameyear.outcome.save %>% relocate(NUMCASO, .before = PWRP) 

TT.sameyear.outcome.save.casos <-  subset (TT.sameyear.outcome.save, select = c(NUMCASO,cases))
TT.sameyear.outcome.save <-  subset (TT.sameyear.outcome.save, select = -cases)

# imprime os casos filtrados pelos limiares de consistência e de PRI
sufficiency.outcome <- subset(sufficiency.outcome, (incl >= parm.consistencia & PRI >= parm.pri))


#  outcome negated

parm.outcome <- "~OUTCOME"
parm.negacao.ESA <- TRUE
truthtable.sameyear.outcome.negated <- gera.tabela.verdade (parm.matriz, parm.outcome, 
                                                            parm.consistencia, parm.frequencia,
                                                            parm.pri, parm.conditions,
                                                            parm.inclui.non.party,
                                                            parm.inclui.polarization,
                                                            parm.inclui.single.party,
                                                            parm.complete, parm.show.cases,
                                                            aplica.ESA, parm.negacao.ESA)


### imprime em arquivo a tabela verdade gerada no console
impressao.console <- imprime.console.para.conferencia(truthtable.sameyear.outcome.negated$tt,
                                                      parm.tipo.saida = paste("tt", parm.addition.filename, sep="."), 
                                                      parm.arquivo.outcome = "negated",
                                                      parm.arquivo.tempo = "sameyear",
                                                      parm.append = FALSE,
                                                      parm.titulo = NA,
                                                      parm.confere.consistencia.min <- parm.consistencia.minimizacao)


sufficiency.outcome.negated <- truthtable.sameyear.outcome.negated$tt 


for (k in 1:nrow(sufficiency.outcome.negated))
{
  if ( is.numeric (sufficiency.outcome.negated$incl [k]) )
  {
    sufficiency.outcome.negated$PRI.as.pct.Consist [k] <- round ((sufficiency.outcome.negated$PRI [k]/sufficiency.outcome.negated$incl [k]), digits = 4)  
  }
}   # endfor
sufficiency.outcome.negated <- sufficiency.outcome.negated %>% relocate(PRI.as.pct.Consist, .after = PRI) 

#imprime a tabela verdade completa (1 planilha com todas as condições lógicas,
#  outra planilha com os casos)
TT.sameyear.outcome.negated.save <-  sufficiency.outcome.negated
TT.sameyear.outcome.negated.save$NUMCASO <- rownames(sufficiency.outcome.negated)
TT.sameyear.outcome.negated.save <- TT.sameyear.outcome.negated.save %>% relocate(NUMCASO, .before = PWRP) 

TT.sameyear.outcome.negated.save.casos <-  subset (TT.sameyear.outcome.negated.save, select = c(NUMCASO,cases))
TT.sameyear.outcome.negated.save <-  subset (TT.sameyear.outcome.negated.save, select = -cases)

# imprime os casos filtrados pelos limiares de consistência e de PRI
sufficiency.outcome.negated <- subset(sufficiency.outcome.negated, (incl >= parm.consistencia & PRI >= parm.pri))


## TRABALHA COM A MATRIZ DE CASOS LAGGED

parm.matriz <- matriz.de.casos.lagged.carga


#  outcome

parm.outcome <- "OUTCOME_LAGGED"
parm.negacao.ESA <- FALSE

truthtable.lagged.outcome <- gera.tabela.verdade (parm.matriz, parm.outcome, 
                                                  parm.consistencia, parm.frequencia,
                                                  parm.pri,parm.conditions,
                                                  parm.inclui.non.party,
                                                  parm.inclui.polarization,
                                                  parm.inclui.single.party,
                                                  parm.complete, parm.show.cases,
                                                  aplica.ESA, parm.negacao.ESA)


### imprime em arquivo a tabela verdade gerada no console
impressao.console <- imprime.console.para.conferencia(truthtable.lagged.outcome$tt,
                                                      parm.tipo.saida = paste("tt", parm.addition.filename, sep="."), 
                                                      parm.arquivo.outcome = "outcome",
                                                      parm.arquivo.tempo = "lagged",
                                                      parm.append = FALSE,
                                                      parm.titulo = NA,
                                                      parm.confere.consistencia.min <- parm.consistencia.minimizacao)


sufficiency.outcome.lagged <- truthtable.lagged.outcome$tt 

for (k in 1:nrow(sufficiency.outcome.lagged))
{
  if ( is.numeric (sufficiency.outcome.lagged$incl [k]) )
  {
    sufficiency.outcome.lagged$PRI.as.pct.Consist [k] <- round ((sufficiency.outcome.lagged$PRI [k]/sufficiency.outcome.lagged$incl [k]), digits = 4)  
  }
}   # endfor
sufficiency.outcome.lagged <- sufficiency.outcome.lagged %>% relocate(PRI.as.pct.Consist, .after = PRI) 



#imprime a tabela verdade completa (1 planilha com todas as condições lógicas,
#  outra planilha com os casos)
TT.lagged.outcome.save <-  sufficiency.outcome.lagged
TT.lagged.outcome.save$NUMCASO <- rownames(sufficiency.outcome.lagged)
TT.lagged.outcome.save <- TT.lagged.outcome.save %>% relocate(NUMCASO, .before = PWRP) 

TT.lagged.outcome.save.casos <-  subset (TT.lagged.outcome.save, select = c(NUMCASO,cases))
TT.lagged.outcome.save <-  subset (TT.lagged.outcome.save, select = -cases)

# imprime os casos filtrados pelos limiares de consistência e de PRI
sufficiency.outcome.lagged <- subset(sufficiency.outcome.lagged, (incl >= parm.consistencia & PRI >= parm.pri))

#  outcome negated

parm.outcome <- "~OUTCOME_LAGGED"
parm.negacao.ESA <- TRUE
truthtable.lagged.outcome.negated <- gera.tabela.verdade (parm.matriz, parm.outcome, 
                                                          parm.consistencia, parm.frequencia,
                                                          parm.pri,parm.conditions,
                                                          parm.inclui.non.party,
                                                          parm.inclui.polarization,
                                                          parm.inclui.single.party,
                                                          parm.complete, parm.show.cases,
                                                          aplica.ESA, parm.negacao.ESA)

### imprime em arquivo a tabela verdade gerada no console
impressao.console <- imprime.console.para.conferencia(truthtable.lagged.outcome.negated$tt,
                                                      parm.tipo.saida = paste("tt", parm.addition.filename, sep="."), 
                                                      parm.arquivo.outcome = "negated",
                                                      parm.arquivo.tempo = "lagged",
                                                      parm.append = FALSE,
                                                      parm.titulo = NA,
                                                      parm.confere.consistencia.min <- parm.consistencia.minimizacao)


sufficiency.outcome.negated.lagged <- truthtable.lagged.outcome.negated$tt 


for (k in 1:nrow(sufficiency.outcome.negated.lagged))
{
  if ( is.numeric (sufficiency.outcome.negated.lagged$incl [k]) )
  {
    sufficiency.outcome.negated.lagged$PRI.as.pct.Consist [k] <- round ((sufficiency.outcome.negated.lagged$PRI [k]/sufficiency.outcome.negated.lagged$incl [k]), digits = 4)  
  }
}   # endfor

sufficiency.outcome.negated.lagged <- sufficiency.outcome.negated.lagged %>% relocate(PRI.as.pct.Consist, .after = PRI) 

#imprime a tabela verdade completa (1 planilha com todas as condições lógicas,
#  outra planilha com os casos)
TT.lagged.outcome.negated.save <-  sufficiency.outcome.negated.lagged
TT.lagged.outcome.negated.save$NUMCASO <- rownames(sufficiency.outcome.negated.lagged)
TT.lagged.outcome.negated.save <- TT.lagged.outcome.negated.save %>% relocate(NUMCASO, .before = PWRP) 

TT.lagged.outcome.negated.save.casos <-  subset (TT.lagged.outcome.negated.save, select = c(NUMCASO,cases))
TT.lagged.outcome.negated.save <-  subset (TT.lagged.outcome.negated.save, select = -cases)

# imprime os casos filtrados pelos limiares de consistência e de PRI

sufficiency.outcome.negated.lagged <- subset(sufficiency.outcome.negated.lagged, (incl >= parm.consistencia & PRI >= parm.pri))

####
#####  minimização  
####

              
## providencias adicionais para impressao em arquivo dos resultados
##
##



parm.label.simplifying.assumptions <- "Simplifying assumptions" 
parm.simplifying.assumptions <- NULL


# para puxar as linhas imputadas pela solução intermediária  
#  <estrutura que sai do minimize>$i.sol$C1P1$EC  (os easy counterfactuals)
#  <estrutura que sai do minimize>$i.sol$C1P1$DC  (os difficult counterfactuals)
  #  <estrutura que sai do minimize>$i.sol$C1P1$NSEC  (os non-simplifying easy counterfactuals)x'  

#############################################################
##  mesmo ano
#


############# outcome

# conservative solution 

cons.solution.sameyear.outcome <- minimize (truthtable.sameyear.outcome,
                                            include = "1",
                                            sol.cons = parm.consistencia.minimizacao,
                                            details = TRUE, use.tilde = TRUE)
  
  
### grava dados de minimização
parm.tipo <- "OUTCOME, SAME YEAR, CONSERVATIVE"
parm.solucoes <- cons.solution.sameyear.outcome$IC$incl.cov
parm.solucoes.combinadas <- cons.solution.sameyear.outcome$IC$sol.incl.cov


parm.simplifying.assumptions <- NULL
cons.minimized.sameyear <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                     parm.tipo, parm.label.simplifying.assumptions,
                                     parm.simplifying.assumptions) 

# parsimonious solution 

pars.solution.sameyear.outcome <- minimize (truthtable.sameyear.outcome,
                                            include = "?",
                                            sol.cons = parm.consistencia.minimizacao,
                                            details = TRUE, use.tilde = TRUE,
                                            dir.exp = NULL)


### grava dados de minimização
parm.tipo <- "OUTCOME, SAME YEAR, PARSIMONIOUS"

# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(pars.solution.sameyear.outcome$IC$incl.cov)  )
{  
 parm.solucoes <- pars.solution.sameyear.outcome$IC$overall$incl.cov
 parm.solucoes.combinadas <- pars.solution.sameyear.outcome$IC$overall$sol.incl.cov
} else
{
 parm.solucoes <- pars.solution.sameyear.outcome$IC$incl.cov
 parm.solucoes.combinadas <- pars.solution.sameyear.outcome$IC$sol.incl.cov
}
parm.simplifying.assumptions <- pars.solution.sameyear.outcome$SA$M1

pars.minimized.sameyear <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                       parm.tipo, parm.label.simplifying.assumptions,
                                       parm.simplifying.assumptions) 


# intermediate solution 
interm.solution.sameyear.outcome <- minimize (truthtable.sameyear.outcome,
                                            include = "?",
                                            sol.cons = parm.consistencia.minimizacao,
                                            details = TRUE, use.tilde = TRUE,
                                            dir.exp = directional.expectations.outcome
                                            )


### imprime em arquivo as solucoes de minimizacao geradas no console

imagem.console.sameyear.outcome <- imprime.console.para.conferencia (cons.solution.sameyear.outcome,
                                                       parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."),
                                                       parm.arquivo.outcome = "outcome",
                                                       parm.arquivo.tempo = "sameyear",
                                                       parm.append = FALSE,
                                                       parm.titulo = "CONSERVATIVE",
                                                       parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.sameyear.outcome <- imprime.console.para.conferencia (pars.solution.sameyear.outcome,
                                                       parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                       parm.arquivo.outcome = "outcome",
                                                       parm.arquivo.tempo = "sameyear",
                                                       parm.append = TRUE,
                                                       parm.titulo = "PARSIMONIOUS",
                                                       parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.sameyear.outcome <- imprime.console.para.conferencia (interm.solution.sameyear.outcome,
                                                       parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                       parm.arquivo.outcome = "outcome",
                                                       parm.arquivo.tempo = "sameyear",
                                                       parm.append = TRUE,
                                                       parm.titulo = "INTERMEDIATE",
                                                       parm.confere.consistencia.min <- parm.consistencia.minimizacao)





### grava dados de minimização
parm.tipo <- "OUTCOME, SAME YEAR, INTERMEDIATE"

# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(interm.solution.sameyear.outcome$IC$incl.cov)  )
{  
  parm.solucoes <- interm.solution.sameyear.outcome$IC$overall$incl.cov
  parm.solucoes.combinadas <- interm.solution.sameyear.outcome$IC$overall$sol.incl.cov
} else
{  
  parm.solucoes <- interm.solution.sameyear.outcome$IC$incl.cov
  parm.solucoes.combinadas <- interm.solution.sameyear.outcome$IC$sol.incl.cov
}


parm.simplifying.assumptions <- interm.solution.sameyear.outcome$SA$M1

interm.minimized.sameyear <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                            parm.tipo, parm.label.simplifying.assumptions,
                                            parm.simplifying.assumptions)  

## consolida as diferentes soluções 

minimized.sameyear <- rbind (cons.minimized.sameyear, pars.minimized.sameyear, 
                             interm.minimized.sameyear)

##################### outcome, negated


# conservative solution 

cons.solution.sameyear.outcome.negated <- minimize (truthtable.sameyear.outcome.negated,
                                            include = "1",
                                            sol.cons = parm.consistencia.minimizacao,
                                            details = TRUE, use.tilde = TRUE)


### grava dados de minimização
parm.tipo <- " ~ OUTCOME, SAME YEAR, CONSERVATIVE"
parm.solucoes <- cons.solution.sameyear.outcome.negated$IC$incl.cov
parm.solucoes.combinadas <- cons.solution.sameyear.outcome.negated$IC$sol.incl.cov

parm.simplifying.assumptions <- NULL
cons.minimized.sameyear.negated <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                               parm.tipo, parm.label.simplifying.assumptions,
                                               parm.simplifying.assumptions) 

                                               
# parsimonious solution 

pars.solution.sameyear.outcome.negated <- minimize (truthtable.sameyear.outcome.negated,
                                            include = "?",
                                            sol.cons = parm.consistencia.minimizacao,
                                            details = TRUE, use.tilde = TRUE)



### grava dados de minimização
parm.tipo <- " ~ OUTCOME, SAME YEAR, PARSIMONIOUS"

# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(pars.solution.sameyear.outcome.negated$IC$incl.cov)  )
{
  parm.solucoes <- pars.solution.sameyear.outcome.negated$IC$overall$incl.cov
  parm.solucoes.combinadas <- pars.solution.sameyear.outcome.negated$IC$overall$sol.incl.cov
} else
{
  parm.solucoes <- pars.solution.sameyear.outcome.negated$IC$incl.cov
  parm.solucoes.combinadas <- pars.solution.sameyear.outcome.negated$IC$sol.incl.cov
}
parm.simplifying.assumptions <- pars.solution.sameyear.outcome.negated$SA$M1

pars.minimized.sameyear.negated <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                                    parm.tipo, parm.label.simplifying.assumptions,
                                                    parm.simplifying.assumptions)

# intermediate solution 

interm.solution.sameyear.outcome.negated <- minimize (truthtable.sameyear.outcome.negated,
                                                    include = "?",
                                                    sol.cons = parm.consistencia.minimizacao,
                                                    details = TRUE, use.tilde = TRUE,
                                                    dir.exp = directional.expectations.negation)


### grava dados de minimização
parm.tipo <- " ~ OUTCOME, SAME YEAR, INTERMEDIATE"

# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(interm.solution.sameyear.outcome.negated$IC$incl.cov)  )
{
  parm.solucoes <- interm.solution.sameyear.outcome.negated$IC$overall$incl.cov
  parm.solucoes.combinadas <- interm.solution.sameyear.outcome.negated$IC$overall$sol.incl.cov
} else
{
  parm.solucoes <- interm.solution.sameyear.outcome.negated$IC$incl.cov
  parm.solucoes.combinadas <- interm.solution.sameyear.outcome.negated$IC$sol.incl.cov
} 
parm.simplifying.assumptions <- interm.solution.sameyear.outcome.negated$SA$M1

interm.minimized.sameyear.negated <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                                    parm.tipo, parm.label.simplifying.assumptions,
                                                    parm.simplifying.assumptions)

## consolida as diferentes soluções                                                 
minimized.sameyear.negated <- rbind (cons.minimized.sameyear.negated, pars.minimized.sameyear.negated,
                                     interm.minimized.sameyear.negated)

### imprime em arquivo as solucoes de minimizacao geradas no console
imagem.console.sameyear.negated <- imprime.console.para.conferencia (cons.solution.sameyear.outcome.negated,
                                                                     parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."),
                                                                     parm.arquivo.outcome = "negated",
                                                                     parm.arquivo.tempo = "sameyear",
                                                                     parm.append = FALSE,
                                                                     parm.titulo = "CONSERVATIVE",
                                                                     parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.sameyear.negated <- imprime.console.para.conferencia (pars.solution.sameyear.outcome.negated,
                                                                     parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                                     parm.arquivo.outcome = "negated",
                                                                     parm.arquivo.tempo = "sameyear",
                                                                     parm.append = TRUE,
                                                                     parm.titulo = "PARSIMONIOUS",
                                                                     parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.sameyear.negated <- imprime.console.para.conferencia (interm.solution.sameyear.outcome.negated,
                                                                     parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                                     parm.arquivo.outcome = "negated",
                                                                     parm.arquivo.tempo = "sameyear",
                                                                     parm.append = TRUE,
                                                                     parm.titulo = "INTERMEDIATE",
                                                                     parm.confere.consistencia.min <- parm.consistencia.minimizacao)


                            
#################################################################
##  lagged
#

# ################outcome lagged

# conservative solution

cons.solution.lagged.outcome <- minimize (truthtable.lagged.outcome,
                                            include = "1",
                                            sol.cons = parm.consistencia.minimizacao,
                                            details = TRUE, use.tilde = TRUE)

### grava dados de minimização
parm.tipo <- "OUTCOME, LAGGED, CONSERVATIVE"
parm.solucoes <- cons.solution.lagged.outcome$IC$incl.cov
parm.solucoes.combinadas <- cons.solution.lagged.outcome$IC$sol.incl.cov
parm.simplifying.assumptions <- NULL

cons.minimized.lagged <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                     parm.tipo, parm.label.simplifying.assumptions,
                                     parm.simplifying.assumptions) 

# parsimonious solution

pars.solution.lagged.outcome <- minimize (truthtable.lagged.outcome,
                                          include = "?",
                                          sol.cons = parm.consistencia.minimizacao,
                                          details = TRUE, use.tilde = TRUE,
                                          dir.exp = NULL)

### grava dados de minimização
parm.tipo <- "OUTCOME, LAGGED, PARSIMONIOUS"
# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(pars.solution.lagged.outcome$IC$incl.cov)  )
{
  parm.solucoes <- pars.solution.lagged.outcome$IC$overall$incl.cov
  parm.solucoes.combinadas <- pars.solution.lagged.outcome$IC$overall$sol.incl.cov
} else
{
  parm.solucoes <- pars.solution.lagged.outcome$IC$incl.cov
  parm.solucoes.combinadas <- pars.solution.lagged.outcome$IC$sol.incl.cov
}

parm.simplifying.assumptions <- pars.solution.lagged.outcome$SA$M1
pars.minimized.lagged <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                          parm.tipo, parm.label.simplifying.assumptions,
                                          parm.simplifying.assumptions) 

# intermediate solution

interm.solution.lagged.outcome <- minimize (truthtable.lagged.outcome,
                                          include = "?",
                                          sol.cons = parm.consistencia.minimizacao,
                                          details = TRUE, use.tilde = TRUE,
                                          dir.exp = directional.expectations.outcome)

### grava dados de minimização
parm.tipo <- "OUTCOME, LAGGED, INTERMEDIATE"

# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(interm.solution.lagged.outcome$IC$incl.cov)  )
{
parm.solucoes <- interm.solution.lagged.outcome$IC$overall$incl.cov
parm.solucoes.combinadas <- interm.solution.lagged.outcome$IC$overall$sol.incl.cov
} else
{
  parm.solucoes <- interm.solution.lagged.outcome$IC$incl.cov
  parm.solucoes.combinadas <- interm.solution.lagged.outcome$IC$sol.incl.cov
}
parm.simplifying.assumptions <- interm.solution.lagged.outcome$SA$M1

interm.minimized.lagged <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                          parm.tipo, parm.label.simplifying.assumptions,
                                          parm.simplifying.assumptions) 


## consolida as diferentes soluções                                                 
minimized.lagged <- rbind (cons.minimized.lagged, pars.minimized.lagged,
                           interm.minimized.lagged)

### imprime em arquivo as solucoes de minimizacao geradas no console
imagem.console.lagged.outcome <- imprime.console.para.conferencia (cons.solution.lagged.outcome,
                                                                     parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."),
                                                                     parm.arquivo.outcome = "outcome",
                                                                     parm.arquivo.tempo = "lagged",
                                                                     parm.append = FALSE,
                                                                     parm.titulo = "CONSERVATIVE",
                                                                   parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.lagged.outcome <- imprime.console.para.conferencia (pars.solution.lagged.outcome,
                                                                     parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                                     parm.arquivo.outcome = "outcome",
                                                                     parm.arquivo.tempo = "lagged",
                                                                     parm.append = TRUE,
                                                                     parm.titulo = "PARSIMONIOUS",
                                                                   parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.lagged.outcome <- imprime.console.para.conferencia (interm.solution.lagged.outcome,
                                                                     parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                                     parm.arquivo.outcome = "outcome",
                                                                     parm.arquivo.tempo = "lagged",
                                                                     parm.append = TRUE,
                                                                     parm.titulo = "INTERMEDIATE",
                                                                   parm.confere.consistencia.min <- parm.consistencia.minimizacao)



############################ outcome negated, lagged


# conservative solution

#teste.resultado <- try (minimize (truthtable.lagged.outcome.negated,
#               include = "1",
#               sol.cons = parm.consistencia.minimizacao,
#               details = TRUE, use.tilde = TRUE),
#     silent = TRUE
#)
#if (inherits(teste.resultado, "try-error"))
#{a <- 2
#a}

cons.solution.lagged.outcome.negated <- minimize (truthtable.lagged.outcome.negated,
                                          include = "1",
                                          sol.cons = parm.consistencia.minimizacao,
                                          details = TRUE, use.tilde = TRUE)

### grava dados de minimização
parm.tipo <- " ~ OUTCOME, LAGGED, CONSERVATIVE"
parm.solucoes <- cons.solution.lagged.outcome.negated$IC$incl.cov
parm.solucoes.combinadas <- cons.solution.lagged.outcome.negated$IC$sol.incl.cov

parm.simplifying.assumptions <- NULL

cons.minimized.lagged.negated <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                     parm.tipo, parm.label.simplifying.assumptions,
                                     parm.simplifying.assumptions) 


# parsimonious solution
pars.solution.lagged.outcome.negated <- minimize (truthtable.lagged.outcome.negated,
                                                  include = "?",
                                                  sol.cons = parm.consistencia.minimizacao,
                                                  details = TRUE, use.tilde = TRUE,
                                                  dir.exp = NULL)

### grava dados de minimização
parm.tipo <- " ~ OUTCOME, LAGGED, PARSIMONIOUS"

# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(pars.solution.lagged.outcome.negated$IC$incl.cov)  )
{
  parm.solucoes <- pars.solution.lagged.outcome.negated$IC$overall$incl.cov
  parm.solucoes.combinadas <- pars.solution.lagged.outcome.negated$IC$overall$sol.incl.cov
} else
{
  parm.solucoes <- pars.solution.lagged.outcome.negated$IC$incl.cov
  parm.solucoes.combinadas <- pars.solution.lagged.outcome.negated$IC$sol.incl.cov
  
}
parm.simplifying.assumptions <- pars.solution.lagged.outcome.negated$SA$M1

pars.minimized.lagged.negated <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                                  parm.tipo, parm.label.simplifying.assumptions,
                                                  parm.simplifying.assumptions) 

# intermediate solution
interm.solution.lagged.outcome.negated <- minimize (truthtable.lagged.outcome.negated,
                                                    include = "?",
                                                    sol.cons = parm.consistencia.minimizacao,
                                                    details = TRUE, use.tilde = TRUE,
                                                    dir.exp = directional.expectations.negation) 

### grava dados de minimização
parm.tipo <- " ~ OUTCOME, LAGGED, INTERMEDIATE"

# trata o caso de que algumas soluções têm um IC como lista múltipla
if ( is.null(interm.solution.lagged.outcome.negated$IC$incl.cov)  )
{
  parm.solucoes <- interm.solution.lagged.outcome.negated$IC$overall$incl.cov
  parm.solucoes.combinadas <- interm.solution.lagged.outcome.negated$IC$overall$sol.incl.cov
} else
{
  parm.solucoes <- interm.solution.lagged.outcome.negated$IC$incl.cov
  parm.solucoes.combinadas <- interm.solution.lagged.outcome.negated$IC$sol.incl.cov 
}
parm.simplifying.assumptions <- interm.solution.lagged.outcome.negated$SA$M1

interm.minimized.lagged.negated <- grava.minimized (parm.solucoes, parm.solucoes.combinadas,
                                                  parm.tipo, parm.label.simplifying.assumptions,
                                                  parm.simplifying.assumptions) 





## consolida as diferentes soluções                                                 

minimized.lagged.negated <- rbind (cons.minimized.lagged.negated, pars.minimized.lagged.negated,
                                   interm.minimized.lagged.negated)


### imprime em arquivo as solucoes de minimizacao geradas no console
imagem.console.lagged.negated <- imprime.console.para.conferencia (cons.solution.lagged.outcome.negated,
                                                                   parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."),
                                                                   parm.arquivo.outcome = "negated",
                                                                   parm.arquivo.tempo = "lagged",
                                                                   parm.append = FALSE,
                                                                   parm.titulo = "CONSERVATIVE",
                                                                   parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.lagged.negated <- imprime.console.para.conferencia (pars.solution.lagged.outcome.negated,
                                                                   parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                                   parm.arquivo.outcome = "negated",
                                                                   parm.arquivo.tempo = "lagged",
                                                                   parm.append = TRUE,
                                                                   parm.titulo = "PARSIMONIOUS",
                                                                   parm.confere.consistencia.min <- parm.consistencia.minimizacao)

imagem.console.lagged.negated <- imprime.console.para.conferencia (interm.solution.lagged.outcome.negated,
                                                                   parm.tipo.saida = paste("minimiz", parm.addition.filename, sep="."), 
                                                                   parm.arquivo.outcome = "negated",
                                                                   parm.arquivo.tempo = "lagged",
                                                                   parm.append = TRUE,
                                                                   parm.titulo = "INTERMEDIATE",
                                                                   parm.confere.consistencia.min <- parm.consistencia.minimizacao)

####
######   imprime resultados QCA
######
####


data.e.hora.gravacao <- as.character (now())



#  resultados para necessity 

necessity.header <- as.data.frame(c("Necessity Analysis", "File saved at ",
                                    data.e.hora.gravacao))
colnames(necessity.header) <- " "

QCA.results.necessity <- list (Necessity = necessity.header,
                               Necessity_Threshold = necessity.parameters, 
                               Necessity_YR = necessity.outcome,
                               Necessity_Negation_YR = necessity.outcome.negation,
                               Necessity_Lagged = necessity.outcome.lagged,
                               Necessity_Negation_Lagged = necessity.outcome.negation.lagged)                      


write_xlsx(
  QCA.results.necessity,
  path = nome.arquivo.necessity,  
  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)


#  resultados para truth table 

truth.table.header <- as.data.frame(c("Truth Table", "File saved at ",
                                      data.e.hora.gravacao, 
                                      "Analisa por mandato", parm.analisa.por.mandato,
                                      "Abre por mandatos de um ano e de mais de um", parm.inclui.long.mandate,
                                      "Inclui só mandatos de mais de um ano", parm.expurga.mandato.um.ano,
                                      "Exclui lame ducks (ano eleitoral)", parm.retira.lameduck,
                                      "Exclui vice-presidentes", parm.retira.vice,
                                      "Exclui mandatos-tampão", parm.retira.bombeiro))

colnames(truth.table.header) <- " "

QCA.results.truth.table <- list (Truth_Table = truth.table.header,
                                 TT_YR = TT.sameyear.outcome.save,
                                 TT_YR_Casos = TT.sameyear.outcome.save.casos,
                                 TT_Negation_YR = TT.sameyear.outcome.negated.save,
                                 TT_Negation_YR_Casos = TT.sameyear.outcome.negated.save.casos,
                                 TT_Lagged = TT.lagged.outcome.save,
                                 TT_Lagged_Casos = TT.lagged.outcome.save.casos,
                                 TT_Negation_Lagged = TT.lagged.outcome.negated.save,
                                 TT_Negation_Lagged_Casos = TT.lagged.outcome.negated.save.casos)                      

#  explorar:mudei o nome do arquivo xls
write_xlsx(
  QCA.results.truth.table,
  path = nome.arquivo.truthtable,
  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)


#  resultados para sufficiency 

sufficiency.header <- as.data.frame(c("Sufficiency", "File saved at ",
                                      data.e.hora.gravacao))
colnames(sufficiency.header) <- " "

### arredonda os parâmetros da minimização para 4 dígitos para facilitar
### transcriçao para tabelas em word 
 
aux.round.minimiza <- round.parm.minimizacao (minimized.sameyear)
minimized.sameyear <- aux.round.minimiza
aux.round.minimiza <- round.parm.minimizacao (minimized.sameyear.negated)
minimized.sameyear.negated <- aux.round.minimiza
aux.round.minimiza <- round.parm.minimizacao (minimized.lagged)
minimized.lagged <- aux.round.minimiza
aux.round.minimiza <- round.parm.minimizacao (minimized.lagged.negated)
minimized.lagged.negated <- aux.round.minimiza
#######


QCA.results.sufficiency <- list(Sufficency = sufficiency.header, 
                                Sufficiency_parameters = sufficiency.parameters,
                                Sufficiency_YR = sufficiency.outcome,
                                Sufficiency_Negation_YR = sufficiency.outcome.negated,
                                Sufficiency_Lagged = sufficiency.outcome.lagged,
                                Sufficiency_Negation_Lagged = sufficiency.outcome.negated.lagged,
                                Minim_YR = minimized.sameyear,
                                Minim_Negation_YR = minimized.sameyear.negated,
                                Minim_Lagged = minimized.lagged,
                                Minim_Negation_Lagged = minimized.lagged.negated,
                                Console_YR = imagem.console.sameyear.outcome,
                                Console_Negation_YR = imagem.console.sameyear.negated,
                                Console_Lagged = imagem.console.lagged.outcome,
                                Console_Negation_Lagged = imagem.console.lagged.negated
                               )                      

write_xlsx(
  QCA.results.sufficiency,
  path = nome.arquivo.sufficiency,
  col_names = TRUE,
  #  format_headers = TRUE,
  # use_zip64 = TRUE
)
